home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / xml / sax / expatreader.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  13KB  |  407 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. version = '0.20'
  5. from xml.sax._exceptions import *
  6. from xml.sax.handler import feature_validation, feature_namespaces
  7. from xml.sax.handler import feature_namespace_prefixes
  8. from xml.sax.handler import feature_external_ges, feature_external_pes
  9. from xml.sax.handler import feature_string_interning
  10. from xml.sax.handler import property_xml_string, property_interning_dict
  11. import sys
  12. if sys.platform[:4] == 'java':
  13.     raise SAXReaderNotAvailable('expat not available in Java', None)
  14.  
  15. del sys
  16.  
  17. try:
  18.     from xml.parsers import expat
  19. except ImportError:
  20.     raise SAXReaderNotAvailable('expat not supported', None)
  21.  
  22. if not hasattr(expat, 'ParserCreate'):
  23.     raise SAXReaderNotAvailable('expat not supported', None)
  24.  
  25. from xml.sax import xmlreader, saxutils, handler
  26. AttributesImpl = xmlreader.AttributesImpl
  27. AttributesNSImpl = xmlreader.AttributesNSImpl
  28.  
  29. try:
  30.     import _weakref
  31. except ImportError:
  32.     
  33.     def _mkproxy(o):
  34.         return o
  35.  
  36.  
  37. import weakref
  38. _mkproxy = weakref.proxy
  39. del weakref
  40. del _weakref
  41.  
  42. class ExpatLocator(xmlreader.Locator):
  43.     
  44.     def __init__(self, parser):
  45.         self._ref = _mkproxy(parser)
  46.  
  47.     
  48.     def getColumnNumber(self):
  49.         parser = self._ref
  50.         if parser._parser is None:
  51.             return None
  52.         
  53.         return parser._parser.ErrorColumnNumber
  54.  
  55.     
  56.     def getLineNumber(self):
  57.         parser = self._ref
  58.         if parser._parser is None:
  59.             return 1
  60.         
  61.         return parser._parser.ErrorLineNumber
  62.  
  63.     
  64.     def getPublicId(self):
  65.         parser = self._ref
  66.         if parser is None:
  67.             return None
  68.         
  69.         return parser._source.getPublicId()
  70.  
  71.     
  72.     def getSystemId(self):
  73.         parser = self._ref
  74.         if parser is None:
  75.             return None
  76.         
  77.         return parser._source.getSystemId()
  78.  
  79.  
  80.  
  81. class ExpatParser(xmlreader.IncrementalParser, xmlreader.Locator):
  82.     
  83.     def __init__(self, namespaceHandling = 0, bufsize = 65516):
  84.         xmlreader.IncrementalParser.__init__(self, bufsize)
  85.         self._source = xmlreader.InputSource()
  86.         self._parser = None
  87.         self._namespaces = namespaceHandling
  88.         self._lex_handler_prop = None
  89.         self._parsing = 0
  90.         self._entity_stack = []
  91.         self._external_ges = 1
  92.         self._interning = None
  93.  
  94.     
  95.     def parse(self, source):
  96.         source = saxutils.prepare_input_source(source)
  97.         self._source = source
  98.         self.reset()
  99.         self._cont_handler.setDocumentLocator(ExpatLocator(self))
  100.         xmlreader.IncrementalParser.parse(self, source)
  101.  
  102.     
  103.     def prepareParser(self, source):
  104.         if source.getSystemId() != None:
  105.             self._parser.SetBase(source.getSystemId())
  106.         
  107.  
  108.     
  109.     def setContentHandler(self, handler):
  110.         xmlreader.IncrementalParser.setContentHandler(self, handler)
  111.         if self._parsing:
  112.             self._reset_cont_handler()
  113.         
  114.  
  115.     
  116.     def getFeature(self, name):
  117.         if name == feature_namespaces:
  118.             return self._namespaces
  119.         elif name == feature_string_interning:
  120.             return self._interning is not None
  121.         elif name in (feature_validation, feature_external_pes, feature_namespace_prefixes):
  122.             return 0
  123.         elif name == feature_external_ges:
  124.             return self._external_ges
  125.         
  126.         raise SAXNotRecognizedException("Feature '%s' not recognized" % name)
  127.  
  128.     
  129.     def setFeature(self, name, state):
  130.         if self._parsing:
  131.             raise SAXNotSupportedException('Cannot set features while parsing')
  132.         
  133.         if name == feature_namespaces:
  134.             self._namespaces = state
  135.         elif name == feature_external_ges:
  136.             self._external_ges = state
  137.         elif name == feature_string_interning:
  138.             if state:
  139.                 if self._interning is None:
  140.                     self._interning = { }
  141.                 
  142.             else:
  143.                 self._interning = None
  144.         elif name == feature_validation:
  145.             if state:
  146.                 raise SAXNotSupportedException('expat does not support validation')
  147.             
  148.         elif name == feature_external_pes:
  149.             if state:
  150.                 raise SAXNotSupportedException('expat does not read external parameter entities')
  151.             
  152.         elif name == feature_namespace_prefixes:
  153.             if state:
  154.                 raise SAXNotSupportedException('expat does not report namespace prefixes')
  155.             
  156.         else:
  157.             raise SAXNotRecognizedException("Feature '%s' not recognized" % name)
  158.  
  159.     
  160.     def getProperty(self, name):
  161.         if name == handler.property_lexical_handler:
  162.             return self._lex_handler_prop
  163.         elif name == property_interning_dict:
  164.             return self._interning
  165.         elif name == property_xml_string:
  166.             if self._parser:
  167.                 if hasattr(self._parser, 'GetInputContext'):
  168.                     return self._parser.GetInputContext()
  169.                 else:
  170.                     raise SAXNotRecognizedException('This version of expat does not support getting the XML string')
  171.             else:
  172.                 raise SAXNotSupportedException('XML string cannot be returned when not parsing')
  173.         
  174.         raise SAXNotRecognizedException("Property '%s' not recognized" % name)
  175.  
  176.     
  177.     def setProperty(self, name, value):
  178.         if name == handler.property_lexical_handler:
  179.             self._lex_handler_prop = value
  180.             if self._parsing:
  181.                 self._reset_lex_handler_prop()
  182.             
  183.         elif name == property_interning_dict:
  184.             self._interning = value
  185.         elif name == property_xml_string:
  186.             raise SAXNotSupportedException("Property '%s' cannot be set" % name)
  187.         else:
  188.             raise SAXNotRecognizedException("Property '%s' not recognized" % name)
  189.  
  190.     
  191.     def feed(self, data, isFinal = 0):
  192.         if not self._parsing:
  193.             self.reset()
  194.             self._parsing = 1
  195.             self._cont_handler.startDocument()
  196.         
  197.         
  198.         try:
  199.             self._parser.Parse(data, isFinal)
  200.         except expat.error:
  201.             e = None
  202.             exc = SAXParseException(expat.ErrorString(e.code), e, self)
  203.             self._err_handler.fatalError(exc)
  204.  
  205.  
  206.     
  207.     def close(self):
  208.         if self._entity_stack:
  209.             return None
  210.         
  211.         self.feed('', isFinal = 1)
  212.         self._cont_handler.endDocument()
  213.         self._parsing = 0
  214.         self._parser = None
  215.  
  216.     
  217.     def _reset_cont_handler(self):
  218.         self._parser.ProcessingInstructionHandler = self._cont_handler.processingInstruction
  219.         self._parser.CharacterDataHandler = self._cont_handler.characters
  220.  
  221.     
  222.     def _reset_lex_handler_prop(self):
  223.         lex = self._lex_handler_prop
  224.         parser = self._parser
  225.         if lex is None:
  226.             parser.CommentHandler = None
  227.             parser.StartCdataSectionHandler = None
  228.             parser.EndCdataSectionHandler = None
  229.             parser.StartDoctypeDeclHandler = None
  230.             parser.EndDoctypeDeclHandler = None
  231.         else:
  232.             parser.CommentHandler = lex.comment
  233.             parser.StartCdataSectionHandler = lex.startCDATA
  234.             parser.EndCdataSectionHandler = lex.endCDATA
  235.             parser.StartDoctypeDeclHandler = self.start_doctype_decl
  236.             parser.EndDoctypeDeclHandler = lex.endDTD
  237.  
  238.     
  239.     def reset(self):
  240.         if self._namespaces:
  241.             self._parser = expat.ParserCreate(self._source.getEncoding(), ' ', intern = self._interning)
  242.             self._parser.namespace_prefixes = 1
  243.             self._parser.StartElementHandler = self.start_element_ns
  244.             self._parser.EndElementHandler = self.end_element_ns
  245.         else:
  246.             self._parser = expat.ParserCreate(self._source.getEncoding(), intern = self._interning)
  247.             self._parser.StartElementHandler = self.start_element
  248.             self._parser.EndElementHandler = self.end_element
  249.         self._reset_cont_handler()
  250.         self._parser.UnparsedEntityDeclHandler = self.unparsed_entity_decl
  251.         self._parser.NotationDeclHandler = self.notation_decl
  252.         self._parser.StartNamespaceDeclHandler = self.start_namespace_decl
  253.         self._parser.EndNamespaceDeclHandler = self.end_namespace_decl
  254.         self._decl_handler_prop = None
  255.         if self._lex_handler_prop:
  256.             self._reset_lex_handler_prop()
  257.         
  258.         self._parser.ExternalEntityRefHandler = self.external_entity_ref
  259.         
  260.         try:
  261.             self._parser.SkippedEntityHandler = self.skipped_entity_handler
  262.         except AttributeError:
  263.             pass
  264.  
  265.         self._parser.SetParamEntityParsing(expat.XML_PARAM_ENTITY_PARSING_UNLESS_STANDALONE)
  266.         self._parsing = 0
  267.         self._entity_stack = []
  268.  
  269.     
  270.     def getColumnNumber(self):
  271.         if self._parser is None:
  272.             return None
  273.         
  274.         return self._parser.ErrorColumnNumber
  275.  
  276.     
  277.     def getLineNumber(self):
  278.         if self._parser is None:
  279.             return 1
  280.         
  281.         return self._parser.ErrorLineNumber
  282.  
  283.     
  284.     def getPublicId(self):
  285.         return self._source.getPublicId()
  286.  
  287.     
  288.     def getSystemId(self):
  289.         return self._source.getSystemId()
  290.  
  291.     
  292.     def start_element(self, name, attrs):
  293.         self._cont_handler.startElement(name, AttributesImpl(attrs))
  294.  
  295.     
  296.     def end_element(self, name):
  297.         self._cont_handler.endElement(name)
  298.  
  299.     
  300.     def start_element_ns(self, name, attrs):
  301.         pair = name.split()
  302.         if len(pair) == 1:
  303.             pair = (None, name)
  304.         elif len(pair) == 3:
  305.             pair = (pair[0], pair[1])
  306.         else:
  307.             pair = tuple(pair)
  308.         newattrs = { }
  309.         qnames = { }
  310.         for aname, value in attrs.items():
  311.             parts = aname.split()
  312.             length = len(parts)
  313.             if length == 1:
  314.                 qname = aname
  315.                 apair = (None, aname)
  316.             elif length == 3:
  317.                 qname = '%s:%s' % (parts[2], parts[1])
  318.                 apair = (parts[0], parts[1])
  319.             else:
  320.                 qname = parts[1]
  321.                 apair = tuple(parts)
  322.             newattrs[apair] = value
  323.             qnames[apair] = qname
  324.         
  325.         self._cont_handler.startElementNS(pair, None, AttributesNSImpl(newattrs, qnames))
  326.  
  327.     
  328.     def end_element_ns(self, name):
  329.         pair = name.split()
  330.         if len(pair) == 1:
  331.             pair = (None, name)
  332.         elif len(pair) == 3:
  333.             pair = (pair[0], pair[1])
  334.         else:
  335.             pair = tuple(pair)
  336.         self._cont_handler.endElementNS(pair, None)
  337.  
  338.     
  339.     def processing_instruction(self, target, data):
  340.         self._cont_handler.processingInstruction(target, data)
  341.  
  342.     
  343.     def character_data(self, data):
  344.         self._cont_handler.characters(data)
  345.  
  346.     
  347.     def start_namespace_decl(self, prefix, uri):
  348.         self._cont_handler.startPrefixMapping(prefix, uri)
  349.  
  350.     
  351.     def end_namespace_decl(self, prefix):
  352.         self._cont_handler.endPrefixMapping(prefix)
  353.  
  354.     
  355.     def start_doctype_decl(self, name, sysid, pubid, has_internal_subset):
  356.         self._lex_handler_prop.startDTD(name, pubid, sysid)
  357.  
  358.     
  359.     def unparsed_entity_decl(self, name, base, sysid, pubid, notation_name):
  360.         self._dtd_handler.unparsedEntityDecl(name, pubid, sysid, notation_name)
  361.  
  362.     
  363.     def notation_decl(self, name, base, sysid, pubid):
  364.         self._dtd_handler.notationDecl(name, pubid, sysid)
  365.  
  366.     
  367.     def external_entity_ref(self, context, base, sysid, pubid):
  368.         if not self._external_ges:
  369.             return 1
  370.         
  371.         source = self._ent_handler.resolveEntity(pubid, sysid)
  372.         if not self._source.getSystemId():
  373.             pass
  374.         source = saxutils.prepare_input_source(source, '')
  375.         self._entity_stack.append((self._parser, self._source))
  376.         self._parser = self._parser.ExternalEntityParserCreate(context)
  377.         self._source = source
  378.         
  379.         try:
  380.             xmlreader.IncrementalParser.parse(self, source)
  381.         except:
  382.             return 0
  383.  
  384.         (self._parser, self._source) = self._entity_stack[-1]
  385.         del self._entity_stack[-1]
  386.         return 1
  387.  
  388.     
  389.     def skipped_entity_handler(self, name, is_pe):
  390.         if is_pe:
  391.             name = '%' + name
  392.         
  393.         self._cont_handler.skippedEntity(name)
  394.  
  395.  
  396.  
  397. def create_parser(*args, **kwargs):
  398.     return ExpatParser(*args, **kwargs)
  399.  
  400. if __name__ == '__main__':
  401.     import xml.sax as xml
  402.     p = create_parser()
  403.     p.setContentHandler(xml.sax.XMLGenerator())
  404.     p.setErrorHandler(xml.sax.ErrorHandler())
  405.     p.parse('../../../hamlet.xml')
  406.  
  407.